package sms_api

import (
	"fmt"
	"math/rand"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"github.com/gogf/gf/v2/util/guid"
)

// SendSMSRequest 发送短信请求
type SendSMSRequest struct {
	Phone     string            `json:"phone" validate:"required"`     // 手机号
	Content   string            `json:"content" validate:"required"`   // 短信内容
	Sign      string            `json:"sign,omitempty"`                // 短信签名
	Type      string            `json:"type,omitempty"`                // 短信类型
	Priority  int               `json:"priority,omitempty"`            // 优先级
	Scheduled *time.Time        `json:"scheduled,omitempty"`           // 定时发送时间
	Metadata  map[string]string `json:"metadata,omitempty"`            // 元数据
}

// Validate 验证请求参数
func (r *SendSMSRequest) Validate() error {
	// 验证手机号
	if err := ValidatePhone(r.Phone); err != nil {
		return err
	}

	// 验证短信内容
	if err := ValidateContent(r.Content); err != nil {
		return err
	}

	// 验证短信签名
	if r.Sign != "" {
		if err := ValidateSign(r.Sign); err != nil {
			return err
		}
	}

	// 验证短信类型
	if r.Type != "" {
		if !IsValidSMSType(r.Type) {
			return NewValidationError("type", "enum", r.Type, "无效的短信类型")
		}
	}

	// 验证优先级
	if r.Priority != 0 {
		if !IsValidPriority(r.Priority) {
			return NewValidationError("priority", "range", r.Priority, "无效的优先级")
		}
	}

	return nil
}

// SendSMSResponse 发送短信响应
type SendSMSResponse struct {
	MessageID string            `json:"message_id"`         // 消息ID
	Status    string            `json:"status"`             // 状态
	Provider  string            `json:"provider"`           // 提供商
	Cost      float64           `json:"cost,omitempty"`     // 费用
	SentAt    time.Time         `json:"sent_at"`            // 发送时间
	Metadata  map[string]string `json:"metadata,omitempty"` // 元数据
}

// BatchSMSRequest 批量发送短信请求
type BatchSMSRequest struct {
	Requests []*SendSMSRequest `json:"requests" validate:"required,min=1,max=1000"` // 短信请求列表
	BatchID  string            `json:"batch_id,omitempty"`                         // 批次ID
}

// Validate 验证批量请求参数
func (r *BatchSMSRequest) Validate() error {
	if len(r.Requests) == 0 {
		return NewValidationError("requests", "required", len(r.Requests), "请求列表不能为空")
	}

	if len(r.Requests) > MaxBatchSize {
		return NewValidationError("requests", "max", len(r.Requests), "批量请求数量超过限制")
	}

	for i, req := range r.Requests {
		if err := req.Validate(); err != nil {
			return NewValidationError("requests", "item", i, err.Error())
		}
	}

	return nil
}

// BatchSMSResponse 批量发送短信响应
type BatchSMSResponse struct {
	BatchID   string               `json:"batch_id"`   // 批次ID
	Total     int                  `json:"total"`      // 总数
	Success   int                  `json:"success"`    // 成功数
	Failed    int                  `json:"failed"`     // 失败数
	Results   []*BatchSMSResult    `json:"results"`    // 结果列表
	StartedAt time.Time            `json:"started_at"` // 开始时间
	FinishedAt time.Time           `json:"finished_at"` // 完成时间
}

// BatchSMSResult 批量发送结果
type BatchSMSResult struct {
	Index     int                `json:"index"`               // 索引
	Phone     string             `json:"phone"`               // 手机号
	MessageID string             `json:"message_id,omitempty"` // 消息ID
	Status    string             `json:"status"`              // 状态
	Error     *ErrorResponse     `json:"error,omitempty"`     // 错误信息
	SentAt    *time.Time         `json:"sent_at,omitempty"`   // 发送时间
}

// QuerySMSRequest 查询短信状态请求
type QuerySMSRequest struct {
	MessageID string `json:"message_id" validate:"required"` // 消息ID
	Phone     string `json:"phone,omitempty"`                // 手机号
}

// Validate 验证查询请求参数
func (r *QuerySMSRequest) Validate() error {
	if r.MessageID == "" {
		return NewValidationError("message_id", "required", r.MessageID, "消息ID不能为空")
	}

	if r.Phone != "" {
		if err := ValidatePhone(r.Phone); err != nil {
			return err
		}
	}

	return nil
}

// QuerySMSResponse 查询短信状态响应
type QuerySMSResponse struct {
	MessageID    string            `json:"message_id"`              // 消息ID
	Phone        string            `json:"phone"`                   // 手机号
	Content      string            `json:"content"`                 // 短信内容
	Status       string            `json:"status"`                  // 状态
	Provider     string            `json:"provider"`                // 提供商
	SentAt       *time.Time        `json:"sent_at,omitempty"`       // 发送时间
	DeliveredAt  *time.Time        `json:"delivered_at,omitempty"`  // 送达时间
	FailedAt     *time.Time        `json:"failed_at,omitempty"`     // 失败时间
	ErrorCode    string            `json:"error_code,omitempty"`    // 错误代码
	ErrorMessage string            `json:"error_message,omitempty"` // 错误消息
	Cost         float64           `json:"cost,omitempty"`          // 费用
	Metadata     map[string]string `json:"metadata,omitempty"`      // 元数据
}

// ErrorResponse 错误响应
type ErrorResponse struct {
	Code      string                 `json:"code"`                // 错误代码
	Message   string                 `json:"message"`             // 错误消息
	Details   map[string]interface{} `json:"details,omitempty"`   // 错误详情
	Timestamp time.Time              `json:"timestamp"`           // 时间戳
	RequestID string                 `json:"request_id,omitempty"` // 请求ID
}

// CommonResponse 通用响应结构
type CommonResponse struct {
	Success   bool        `json:"success"`             // 是否成功
	Code      string      `json:"code"`                // 响应代码
	Message   string      `json:"message"`             // 响应消息
	Data      interface{} `json:"data,omitempty"`      // 响应数据
	Error     *ErrorResponse `json:"error,omitempty"`  // 错误信息
	Timestamp time.Time   `json:"timestamp"`           // 时间戳
	RequestID string      `json:"request_id,omitempty"` // 请求ID
}

// HealthResponse 健康检查响应
type HealthResponse struct {
	Status    string            `json:"status"`    // 状态
	Version   string            `json:"version"`   // 版本
	Uptime    time.Duration     `json:"uptime"`    // 运行时间
	Timestamp time.Time         `json:"timestamp"` // 时间戳
	Checks    map[string]string `json:"checks"`    // 检查项
}

// MetricsResponse 指标响应
type MetricsResponse struct {
	TotalSent    int64         `json:"total_sent"`    // 总发送量
	TotalSuccess int64         `json:"total_success"` // 总成功量
	TotalFailed  int64         `json:"total_failed"`  // 总失败量
	SuccessRate  float64       `json:"success_rate"`  // 成功率
	AvgLatency   time.Duration `json:"avg_latency"`   // 平均延迟
	MaxLatency   time.Duration `json:"max_latency"`   // 最大延迟
	MinLatency   time.Duration `json:"min_latency"`   // 最小延迟
	RPS          float64       `json:"rps"`           // 每秒请求数
	Timestamp    time.Time     `json:"timestamp"`     // 时间戳
}

// 验证函数

// ValidatePhone 验证手机号
func ValidatePhone(phone string) error {
	if phone == "" {
		return NewInvalidPhoneError(phone)
	}

	// 去除空格和特殊字符
	phone = strings.ReplaceAll(phone, " ", "")
	phone = strings.ReplaceAll(phone, "-", "")
	phone = strings.ReplaceAll(phone, "(", "")
	phone = strings.ReplaceAll(phone, ")", "")

	// 检查长度
	if len(phone) < MinPhoneLength || len(phone) > MaxPhoneLength {
		return NewInvalidPhoneError(phone)
	}

	// 检查中国大陆手机号格式
	if matched, _ := regexp.MatchString(PhonePatternCN, phone); matched {
		return nil
	}

	// 检查国际手机号格式
	if matched, _ := regexp.MatchString(PhonePatternIntl, phone); matched {
		return nil
	}

	return NewInvalidPhoneError(phone)
}

// ValidateContent 验证短信内容
func ValidateContent(content string) error {
	if content == "" {
		return NewInvalidContentError(content, "内容不能为空")
	}

	// 检查长度
	length := utf8.RuneCountInString(content)
	if length < MinContentLength {
		return NewInvalidContentError(content, "内容过短")
	}
	if length > MaxContentLength {
		return NewInvalidContentError(content, "内容过长")
	}

	// 检查是否包含敏感词（简化实现）
	forbiddenWords := []string{"赌博", "色情", "暴力", "诈骗"}
	for _, word := range forbiddenWords {
		if strings.Contains(content, word) {
			return NewInvalidContentError(content, "包含敏感词汇")
		}
	}

	return nil
}

// ValidateSign 验证短信签名
func ValidateSign(sign string) error {
	if sign == "" {
		return NewInvalidSignError(sign)
	}

	// 检查长度
	length := utf8.RuneCountInString(sign)
	if length < MinSignLength || length > MaxSignLength {
		return NewInvalidSignError(sign)
	}

	// 检查格式
	if matched, _ := regexp.MatchString(SignPattern, sign); !matched {
		return NewInvalidSignError(sign)
	}

	return nil
}

// IsValidSMSType 检查短信类型是否有效
func IsValidSMSType(smsType string) bool {
	validTypes := []string{
		SMSTypeVerification,
		SMSTypeNotification,
		SMSTypeMarketing,
		SMSTypeInternational,
	}

	for _, validType := range validTypes {
		if smsType == validType {
			return true
		}
	}
	return false
}

// IsValidPriority 检查优先级是否有效
func IsValidPriority(priority int) bool {
	return priority >= PriorityLow && priority <= PriorityUrgent
}

// FormatPhone 格式化手机号
func FormatPhone(phone string) string {
	// 去除空格和特殊字符
	phone = strings.ReplaceAll(phone, " ", "")
	phone = strings.ReplaceAll(phone, "-", "")
	phone = strings.ReplaceAll(phone, "(", "")
	phone = strings.ReplaceAll(phone, ")", "")

	// 如果是中国大陆手机号，确保以+86开头
	if matched, _ := regexp.MatchString(PhonePatternCN, phone); matched {
		if !strings.HasPrefix(phone, "+86") {
			phone = "+86" + phone
		}
	}

	return phone
}

// GenerateMessageID 生成消息ID
func GenerateMessageID() string {
	return fmt.Sprintf("sms_%d_%d", time.Now().Unix(), rand.Intn(100000))
}

// GenerateBatchID 生成批次ID
func GenerateBatchID() string {
	return fmt.Sprintf("batch_%d_%d", time.Now().Unix(), rand.Intn(100000))
}

// CalculateSuccessRate 计算成功率
func CalculateSuccessRate(success, total int64) float64 {
	if total == 0 {
		return 0
	}
	return float64(success) / float64(total)
}

// EstimateCost 估算费用（简化实现）
func EstimateCost(content string, smsType string) float64 {
	length := utf8.RuneCountInString(content)
	baseCost := 0.05 // 基础费用5分

	// 根据长度计算费用
	if length > 70 {
		baseCost *= float64((length-1)/70 + 1) // 超过70字符按条数计费
	}

	// 根据类型调整费用
	switch smsType {
	case SMSTypeMarketing:
		baseCost *= 1.2 // 营销短信费用更高
	case SMSTypeInternational:
		baseCost *= 3.0 // 国际短信费用更高
	}

	return baseCost
}